import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: DELL
 * Date: 2023-03-30
 * Time: 14:59
 */
public class Training_0328 {

    public static void main(String[] args) {

        // 滑动窗口法 -- 固定长度为 4, 把无法显示到页面上的内容都放到长度无限的页面上
        //  模拟可以知道, 当当前位置为 i 时, U操作光标向上一个位置: (i - 1- 1 + n)%n + 1
        //  D操作 光标向后一个位置 i % n + 1

        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()) {
            int n = scan.nextInt();
            String s = scan.next();
            Mp3_Index(s, n);
        }

    }

    private static void Mp3_Index(String s, int n) {
        // 页面起始位置
        int start = 1;
        // 页面末位置, 如果页面歌曲数目小于4 返回当前小于4 的歌曲数目
        int end = Math.min(n,4);
        // 光标初始位置, 位置都从1 开始, 用于定位窗口位置
        int index = 1;
        for(int i = 0; i < s.length(); i++) {
            if(s.charAt(i) == 'U') {
                // 改变当前光标位置
                index = (index - 1 -1 + n) % n + 1;
            } else if(s.charAt(i) == 'D') {
                index = index % n + 1;
            }

            // 判断滑动窗口是否位置需要改变到下一组 四个的窗口
            if(index < start) {
                // 此时光标应该在当前窗口上面
                start = index;
                end = start + 3;
            } else if (index > end) {
                // 光标在窗口下面
                end = index;
                start = end - 3;
            }
        }

        // 输出窗口内容
        for(int i = start; i <= end; i++) {
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println(index);
    }

    // 模拟洗牌过程
    // 总牌数 2 * n   上半堆和下半堆牌数个 n 张
    // 1 2 3          4 5 6
    // 先放右手最后一张 6  在放左手最后一张 3 以此类推
    // 洗 K 次牌最后逆序输出
    public static void main1(String[] args) {
        Scanner scan = new Scanner(System.in);
        int T = scan.nextInt(); // 表示有几组牌需要洗
        for (int i = 0; i < T; i++) {
            int n = scan.nextInt(); // 上半堆和下半堆得牌数 2n为总牌数
            int k = scan.nextInt(); // 洗牌次数
            // 利用顺序表存储
            ArrayList<Integer> cards = new ArrayList<>(); // 原牌组
            ArrayList<Integer> list1 = new ArrayList<>(); // 上半牌组
            ArrayList<Integer> list2 = new ArrayList<>(); // 下半牌组
            for (int j = 0; j < 2 * n; j++) {
                // 给原牌组初始化
                cards.add(scan.nextInt());
            }

            // 颠倒排序, 利于后续洗牌 == 先放左手后放右手
            Collections.reverse(cards);

            // 模拟洗牌
            for (int x = 0; x < k; x++) {
                // 下一次分牌前清空手上分好的牌, 避免错误读取
                list1.clear();
                list2.clear();
                // 分牌 由于已经颠倒牌序, 此时下半堆牌在左手放list1中
                for (int j = 0; j < n; j++) {
                    list1.add(cards.get(j));
                }
                // 分牌 上半堆在右手
                for (int j = n; j < 2 * n; j++) {
                    list2.add(cards.get(j));
                }

                // 下一次牌组进来前给当前手上的牌清空避免添加在后面获取错误数据
                cards.clear();
                // 洗牌
                for (int j = 0; j < n; j++) {
                    // 先添加下半堆 即左手list1
                    cards.add(list1.get(j));
                    cards.add(list2.get(j));
                }
            }
            // 原本正常的顺序洗牌后颠倒 还需从后向前输出
            // 此时给原本颠倒的牌在翻转成正常排序
            Collections.reverse(cards);
            // 输出牌序, 链表按照数组形式输出, 带有 [] 以及逗号
            System.out.println(cards.toString()
                    .replace("[", "")
                    .replace("]", "")
                    .replace(",", ""));
        }
        scan.close();
    }
}
